package games.patience.control;

import commomgame.Director;
import commomgame.Deck;
import games.patience.core.RegionOfDiscard;
import games.patience.core.RegionOfFoundations;
import games.patience.core.RegionOfReservesPatience;

/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
/**
 * Classe responsável por controlar o jogo.
 * Essa classe se relaciona diretamente com a interface, recebendo assim, as ações que o usuário deseja efetuar.
 * Ou seja, responsável  por iniciar o jogo, criar o baralho, distribuir as cartas, embaralhar o baralho e também por gerir as movimentações.
 * @author Fernanda & Igo
 */
public class PatienceGame {

    private Deck deck = new Deck();
    private RegionOfDiscard regionOfDiscard = new RegionOfDiscard(1);
    private RegionOfFoundations regionOfFoundations = new RegionOfFoundations(4);
    private RegionOfReservesPatience regionOfReserves = new RegionOfReservesPatience(7);

    /**
     * Construtor dessa classe é resposável por realizar o embaralhamento do baralho criado.
     */
    public PatienceGame() {
        deck.shuffle();

    }

    /**
     * Método que retorna a instancia da região de Discarte do jogo
     * @return objeto de RegionOfDiscard
     */
    public RegionOfDiscard getRegionOfDiscard() {
        return regionOfDiscard;
    }

    /**
     *Método que define a região de Discarte do jogo
     * @param regionOfDiscard objeto de RegionOfDiscard
     */
    public void setRegionOfDiscard(RegionOfDiscard regionOfDiscard) {
        this.regionOfDiscard = regionOfDiscard;
    }

    /**
     *Método que retorna a instancia da região de Fundações do jogo
     * @return objeto de RegionOfFoundations
     */
    public RegionOfFoundations getRegionOfFoundations() {
        return regionOfFoundations;
    }

    /**
     *Método que define a região de Fundações  do jogo
     * @param regionOfFoundations objeto de RegionOfFoundations
     */
    public void setRegionOfFoundations(RegionOfFoundations regionOfFoundations) {
        this.regionOfFoundations = regionOfFoundations;
    }

    /**
     *Método que retorna a instancia da região de Reservas do jogo
     * @return objeto de RegionOfReserves
     */
    public RegionOfReservesPatience getRegionOfReserves() {
        return regionOfReserves;
    }

    /**
     *Método que define a região de Reservas  do jogo
     * @param regionOfReserves objeto de RegionOfReserves
     */
    public void setRegionOfReserves(RegionOfReservesPatience regionOfReserves) {
        this.regionOfReserves = regionOfReserves;
    }

    /**
     *Método que realiza o embaralhamento do baralho criado para o jogo
     */
    public void shuffleDeck() {
        this.deck.shuffle();
    }

    /**
     *Método que distribui as cartas para as regiões, assim como, definindo a situação inicial das mesmas nas
     * suas respectivas subregiões, ou seja, definindo quais cartas estarão visíveis no inicio do jogo.
     * @param turnOne True - Uma carta visível na região de discarte. False - Três cartas visíveis na região de discarte.
     */
    public void shareCardsToRegion(boolean turnOne) {
        regionOfDiscard.sendCardsToRegion(24, this.deck.getListOfCards().subList(0, 24));
        if(turnOne)
            regionOfDiscard.setVisibleCards(1);
        else
            regionOfDiscard.setVisibleCards(3);

        regionOfReserves.sendCardsToRegion2(28, this.deck.getListOfCards().subList(24, 52));
    }

    /**
     *Método responsável por mapear a movimentação realizada e chamar as regras que definirão se a carta pode ser movida ou não
     * @param value inteiro que representa o valor da carta a ser movida
     * @param origin string que representa o nome da região de origem da carta
     * @param target string que representa o nome da região de destino da carta
     * @param nipe string que representa o nipe da carta a ser movida
     */
    public boolean moveCard(int value, String origin, String target, String nipe) {

        //mapeia Strings em Regions
        if (origin.charAt(0) == 'R') {
            if (target.charAt(0) == 'F') {
                return Director.invokeRuleReservesFoundations(value, nipe, origin, target, regionOfReserves, regionOfFoundations);
            }
        }


        if (origin.charAt(0) == 'R') {
            if (target.charAt(0) == 'R') {
                return Director.invokeRuleReservesReserves(value, nipe, origin, target, regionOfReserves, regionOfReserves);
            }
        }

        if (origin.charAt(0) == 'F') {
            if (target.charAt(0) == 'R') {
                return Director.invokeRuleFoundationsReserves(value, nipe, origin, target, regionOfFoundations, regionOfReserves);
            }
        }
        if (origin.charAt(0) == 'D') {
            if (target.charAt(0) == 'F') {
                return Director.invokeRuleDiscardFoundations(value, nipe, origin, target, regionOfDiscard, regionOfFoundations);
            }
        }

        if (origin.charAt(0) == 'D') {
            if (target.charAt(0) == 'R') {

                return Director.invokeRuleDiscardReserves(value, nipe, origin, target, regionOfDiscard, regionOfReserves);
            }
        }
        return false;

    }
}
